// 错误处理工具
class ErrorHandler {
    constructor() {
        this.logKey = 'memo_error_logs'
        this.maxLogs = 100 // 最多保存100条错误日志
        
        // 初始化错误处理
        this.initErrorHandler()
    }
    
    // 初始化错误处理
    initErrorHandler() {
        // 捕获全局JS错误
        const originalError = console.error
        console.error = (...args) => {
            this.logError('Console Error', args.join(' '))
            originalError.apply(console, args)
        }
        
        // 在uni-app环境中，window对象可能不完整，需要安全检查
        try {
            // 捕获Promise错误 - 仅在支持的环境中
            if (typeof window !== 'undefined' && window.addEventListener) {
                window.addEventListener('unhandledrejection', (event) => {
                    this.logError('Unhandled Promise Rejection', event.reason)
                })
                
                // 捕获资源加载错误
                window.addEventListener('error', (event) => {
                    if (event.filename) {
                        this.logError('Resource Error', `${event.filename}:${event.lineno}:${event.colno} - ${event.message}`)
                    }
                })
            }
        } catch (e) {
            // 如果addEventListener不可用，静默忽略
        }
    }
    
    // 记录错误日志
    logError(type, message, extra = {}) {
        try {
            const errorLog = {
                id: Date.now() + Math.random(),
                type: type,
                message: message,
                extra: extra,
                timestamp: new Date().toISOString(),
                userAgent: (typeof navigator !== 'undefined' && navigator.userAgent) || 'uni-app',
                url: (typeof window !== 'undefined' && window.location?.href) || 'uni-app'
            }
            
            // 获取现有日志
            const logs = uni.getStorageSync(this.logKey) || []
            
            // 添加新日志
            logs.unshift(errorLog)
            
            // 限制日志数量
            if (logs.length > this.maxLogs) {
                logs.splice(this.maxLogs)
            }
            
            // 保存日志
            uni.setStorageSync(this.logKey, logs)
            
            // 在开发环境下输出到控制台
            if (process.env.NODE_ENV === 'development') {
                console.warn('Error logged:', errorLog)
            }
        } catch (e) {
            // 避免在错误处理中再次出错
            console.warn('Failed to log error:', e)
        }
    }
    
    // 手动记录错误
    handleError(error, context = '') {
        const message = error.message || error.toString()
        const stack = error.stack || ''
        
        this.logError('Manual Error', message, {
            context: context,
            stack: stack
        })
    }
    
    // 记录用户操作错误
    handleUserError(action, error) {
        this.logError('User Action Error', `Action: ${action}, Error: ${error}`)
    }
    
    // 记录API错误
    handleApiError(url, error, response = {}) {
        this.logError('API Error', `URL: ${url}, Error: ${error}`, {
            response: response
        })
    }
    
    // 获取错误日志
    getErrorLogs() {
        return uni.getStorageSync(this.logKey) || []
    }
    
    // 清除错误日志
    clearErrorLogs() {
        uni.removeStorageSync(this.logKey)
        return true
    }
    
    // 导出错误日志
    exportErrorLogs() {
        const logs = this.getErrorLogs()
        const exportData = {
            logs: logs,
            exportTime: new Date().toISOString(),
            totalCount: logs.length
        }
        
        return exportData
    }
}

// 创建全局错误处理实例
const errorHandler = new ErrorHandler()

// 导出工具函数
export const logError = (type, message, extra) => errorHandler.logError(type, message, extra)
export const handleError = (error, context) => errorHandler.handleError(error, context)
export const handleUserError = (action, error) => errorHandler.handleUserError(action, error)
export const handleApiError = (url, error, response) => errorHandler.handleApiError(url, error, response)

// 默认导出错误处理器实例
export default errorHandler 